#include <linux/input.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
int touch_fd;
struct input_event ts;

char bmp0[800*480*4];
char bmp1[800*480*4];
char* p1;

char* p2;

char* dp1;
char* dp2;
char* dp3;
char* dp4;
char* dp5;
char* dp6;
char* dp7;
char* dp8;
char* dp9;

char* xiangce_p;

char* zuo_p;
char* you_p;
char* fanhui_p;

char* tupian1_p;
char* tupian2_p;
char* tupian3_p;

int event(int *x,int *y)
{
    read(touch_fd,&ts,sizeof(ts));
    if(ts.type == 3 && ts.code == 0)
        *x = ts.value*800/1022;
    if(ts.type == 3 && ts.code == 1)
        *y = ts.value*480/598;
}

int event2(int *x,int *y)
{
    read(touch_fd,&ts,sizeof(ts));
    if(ts.type == 3 && ts.code == 0)
        *x = ts.value*800/1022;
    if(ts.type == 3 && ts.code == 1)
        *y = ts.value*480/598;
}

int hua(int t_x, char bmp0[], char bmp1[])
{
    // for(int y=400;y<440;y++)//设置进度条的Y轴位置
    for(int y=150;y<430;y++)//设置进度条的Y轴位置
    {
        for(int x=0;x<800;x++)//设置进度条的长度
        {
            if(t_x>x)//手指滑动的区域
            {
                for(int t = 0; t < 4; t++) {
                    p1[(y*800+x)*4+t]=bmp0[(y*800+x)*4+t];
                }   
            }
            else 
            {
                for(int t = 0; t < 4; t++) {
                    p1[(y*800+x)*4+t]=bmp1[(y*800+x)*4+t];
                }  
            }
        }
    }
}//练习：实现滑动解锁，进度条要滑满屏幕，注意不能出现点击触摸屏最右边就解锁成功的问题

int show_bmp0(char *bmpname, char bmp[])
{
    // 2.打开bmp图片文件
    int bmpfd = open(bmpname,O_RDWR);
    if(bmpfd == -1)
    {
        printf("打开图片失败\n");
        return 0;
    }
    //3.读取bmp图片的数据
    char buf[800*480*3]={0};//800*480:图片像素点总数 *3：C的代码单位是字节
    //跳过表示图片信息的54个字节
    read(bmpfd,buf,54);
    read(bmpfd,buf,800*480*3);
    //添加一个字节
    // char bmp[800*480*4]={0};//每个像素点加入一个字节所以大小变成*4
    for (int i = 0; i < 800*480*4; i++) {
        bmp[i] = 0;
    }
    for(int i=0,j=0;i<800*480*3;i+=3,j+=4)//i+=3:表示每隔RGB加入一个字节,j+=4:表示跳过ARGB
    {
        bmp[j]=buf[i];
        bmp[j+1]=buf[i+1];
        bmp[j+2]=buf[i+2];
        bmp[j+3]=0;
    }
    close(bmpfd);
    return 0;
}

// int show_bmp(char *bmpname, int* p)
// {
//     //1.打开液晶屏文件
//     int lcdfd = open("/dev/fb0",O_RDWR);
//     if(lcdfd == -1)
//     {
//         printf("打开液晶屏失败\n");
//         return 0;
//     }
//     // 2.打开bmp图片文件
//     int bmpfd = open(bmpname,O_RDWR);
//     if(bmpfd == -1)
//     {
//         printf("打开图片失败\n");
//         return 0;
//     }
//     // 内存映射   
//     p = mmap(NULL,800*480*4,PROT_READ|PROT_WRITE,MAP_SHARED,lcdfd,0);

//     //3.读取bmp图片的数据
//     char buf[800*480*3]={0};//800*480:图片像素点总数 *3：C的代码单位是字节
//     //跳过表示图片信息的54个字节
//     read(bmpfd,buf,54);
//     read(bmpfd,buf,800*480*3);
//     //添加一个字节
//     char bmp[800*480*4]={0};//每个像素点加入一个字节所以大小变成*4
//     for(int i=0,j=0;i<800*480*3;i+=3,j+=4)//i+=3:表示每隔RGB加入一个字节,j+=4:表示跳过ARGB
//     {
//         bmp[j]=buf[i];
//         bmp[j+1]=buf[i+1];
//         bmp[j+2]=buf[i+2];
//         bmp[j+3]=0;
//     }

//     //4.将读取出来的图片数据写入到液晶屏上
//     for(int i=0;i<800*480*4;i++)
//     {
//        p[i]=bmp[i];
//     }
//     //write(lcdfd, bmp, 800*480*4);
//     // 5.关闭液晶屏文件、bmp图片文件
//     // close(lcdfd);
//     close(bmpfd);
//     return 0;
// }

int show_bmp(char *bmpname, char* p)
{
    // 2.打开bmp图片文件
    int bmpfd = open(bmpname,O_RDWR);
    if(bmpfd == -1)
    {
        printf("打开图片失败\n");
        return 0;
    }
    //3.读取bmp图片的数据
    char buf[800*480*3]={0};//800*480:图片像素点总数 *3：C的代码单位是字节
    //跳过表示图片信息的54个字节
    read(bmpfd,buf,54);
    read(bmpfd,buf,800*480*3);
    //添加一个字节
    char bmp[800*480*4]={0};//每个像素点加入一个字节所以大小变成*4
    for(int i=0,j=0;i<800*480*3;i+=3,j+=4)//i+=3:表示每隔RGB加入一个字节,j+=4:表示跳过ARGB
    {
        bmp[j]=buf[i];
        bmp[j+1]=buf[i+1];
        bmp[j+2]=buf[i+2];
        bmp[j+3]=0;
    }

    //4.将读取出来的图片数据写入到液晶屏上
    for(int i=0;i<800*480*4;i++)
    {
       p[i]=bmp[i];
    }
    close(bmpfd);
    return 0;
}

int show_bmp2(int lcdfd, char *bmpname, char* p)
{
    // 2.打开bmp图片文件
    int bmpfd = open(bmpname,O_RDWR);
    if(bmpfd == -1)
    {
        printf("打开图片失败\n");
        return 0;
    }
    // 内存映射   
    p = mmap(NULL,800*480*4,PROT_READ|PROT_WRITE,MAP_SHARED,lcdfd,0);

    //3.读取bmp图片的数据
    char buf[800*480*3]={0};//800*480:图片像素点总数 *3：C的代码单位是字节
    //跳过表示图片信息的54个字节
    read(bmpfd,buf,54);
    read(bmpfd,buf,800*480*3);
    //添加一个字节
    char bmp[800*480*4]={0};//每个像素点加入一个字节所以大小变成*4
    for(int i=0,j=0;i<800*480*3;i+=3,j+=4)//i+=3:表示每隔RGB加入一个字节,j+=4:表示跳过ARGB
    {
        bmp[j]=buf[i];
        bmp[j+1]=buf[i+1];
        bmp[j+2]=buf[i+2];
        bmp[j+3]=0;
    }

    //4.将读取出来的图片数据写入到液晶屏上
    for(int i=0;i<800*480*4;i++)
    {
       p[i]=bmp[i];
    }
    //write(lcdfd, bmp, 800*480*4);
    close(bmpfd);
    return 0;
}


int xiangce_bmp(int lcdfd, char *bmpname, char* p)
{
    // 2.打开bmp图片文件
    int bmpfd = open(bmpname,O_RDWR);
    if(bmpfd == -1)
    {
        printf("打开图片失败\n");
        return 0;
    }
    // 内存映射   
    p = mmap(NULL,800*480*4,PROT_READ|PROT_WRITE,MAP_SHARED,lcdfd,0);

    //3.读取bmp图片的数据
    char buf[800*480*3]={0};//800*480:图片像素点总数 *3：C的代码单位是字节
    //跳过表示图片信息的54个字节
    read(bmpfd,buf,54);
    read(bmpfd,buf,800*480*3);
    //添加一个字节
    char bmp[800*480*4]={0};//每个像素点加入一个字节所以大小变成*4
    for(int i=0,j=0;i<800*480*3;i+=3,j+=4)//i+=3:表示每隔RGB加入一个字节,j+=4:表示跳过ARGB
    {
        bmp[j]=buf[i];
        bmp[j+1]=buf[i+1];
        bmp[j+2]=buf[i+2];
        bmp[j+3]=0;
    }

    //60~420(高),30~390(宽)
    //4.将读取出来的图片数据写入到液晶屏上
    for(int y=60;y<420;y++)//设置进度条的Y轴位置
    {
        for(int x=30;x<390;x++)//设置进度条的长度
        {
            for(int t = 0; t < 4; t++) {
                p[(y*800+x)*4+t]=bmp[(y*800+x)*4+t];
            }   
        }
    }
    close(bmpfd);
    return 0;
}


int tupian_bmp(int lcdfd, char *bmpname, char* p, int* flag_tupian)
{
    if (bmpname == "1.bmp") {
        *flag_tupian = 1;
    } else if (bmpname == "2.bmp"){
        *flag_tupian = 2;
    } else {
        *flag_tupian = 3;
    }
    printf("flag_tupian的值为：%d\n", *flag_tupian);

    // 2.打开bmp图片文件
    int bmpfd = open(bmpname,O_RDWR);
    if(bmpfd == -1)
    {
        printf("打开图片失败\n");
        return 0;
    }
    // 内存映射   
    p = mmap(NULL,800*480*4,PROT_READ|PROT_WRITE,MAP_SHARED,lcdfd,0);

    //3.读取bmp图片的数据
    char buf[800*480*3]={0};//800*480:图片像素点总数 *3：C的代码单位是字节
    //跳过表示图片信息的54个字节
    read(bmpfd,buf,54);
    read(bmpfd,buf,800*480*3);
    //添加一个字节
    char bmp[800*480*4]={0};//每个像素点加入一个字节所以大小变成*4
    for(int i=0,j=0;i<800*480*3;i+=3,j+=4)//i+=3:表示每隔RGB加入一个字节,j+=4:表示跳过ARGB
    {
        bmp[j]=buf[i];
        bmp[j+1]=buf[i+1];
        bmp[j+2]=buf[i+2];
        bmp[j+3]=0;
    }

    //60~420(高),30~390(宽)
    //4.将读取出来的图片数据写入到液晶屏上
    for(int y=0;y<480;y++)//设置进度条的Y轴位置
    {
        for(int x=0;x<800;x++)//设置进度条的长度
        {
            for(int t = 0; t < 4; t++) {
                p[(y*800+x)*4+t]=bmp[(y*800+x)*4+t];
            }   
        }
    }
    close(bmpfd);
    return 0;
}

int zuo_bmp(int lcdfd, char *bmpname, char* p)
{
    // 2.打开bmp图片文件
    int bmpfd = open(bmpname,O_RDWR);
    if(bmpfd == -1)
    {
        printf("打开图片失败\n");
        return 0;
    }
    // 内存映射   
    p = mmap(NULL,800*480*4,PROT_READ|PROT_WRITE,MAP_SHARED,lcdfd,0);

    //3.读取bmp图片的数据
    char buf[800*480*3]={0};//800*480:图片像素点总数 *3：C的代码单位是字节
    //跳过表示图片信息的54个字节
    read(bmpfd,buf,54);
    read(bmpfd,buf,800*480*3);
    //添加一个字节
    char bmp[800*480*4]={0};//每个像素点加入一个字节所以大小变成*4
    for(int i=0,j=0;i<800*480*3;i+=3,j+=4)//i+=3:表示每隔RGB加入一个字节,j+=4:表示跳过ARGB
    {
        bmp[j]=buf[i];
        bmp[j+1]=buf[i+1];
        bmp[j+2]=buf[i+2];
        bmp[j+3]=0;
    }

    //380~480(高),0~100(宽)
    //4.将读取出来的图片数据写入到液晶屏上
    for(int y=380,i=0;y<480;y++,i++)//设置进度条的Y轴位置
    {
        for(int x=0,j=0;x<100;x++,j++)//设置进度条的长度
        {
            for(int t = 0; t < 4; t++) {
                p[(y*800+x)*4+t]=bmp[(i*100+j)*4+t];
            }   
        }
    }
    close(bmpfd);
    return 0;
}

int you_bmp(int lcdfd, char *bmpname, char* p)
{
    // 2.打开bmp图片文件
    int bmpfd = open(bmpname,O_RDWR);
    if(bmpfd == -1)
    {
        printf("打开图片失败\n");
        return 0;
    }
    // 内存映射   
    p = mmap(NULL,800*480*4,PROT_READ|PROT_WRITE,MAP_SHARED,lcdfd,0);

    //3.读取bmp图片的数据
    char buf[100*100*3]={0};//800*480:图片像素点总数 *3：C的代码单位是字节
    //跳过表示图片信息的54个字节
    read(bmpfd,buf,54);
    read(bmpfd,buf,100*100*3);
    //添加一个字节
    char bmp[100*100*4]={0};//每个像素点加入一个字节所以大小变成*4
    for(int i=0,j=0;i<100*100*3;i+=3,j+=4)//i+=3:表示每隔RGB加入一个字节,j+=4:表示跳过ARGB
    {
        bmp[j]=buf[i];
        bmp[j+1]=buf[i+1];
        bmp[j+2]=buf[i+2];
        bmp[j+3]=0;
    }

    //380~480(高),700~800(宽)
    //4.将读取出来的图片数据写入到液晶屏上
    for(int y=380,i=0;y<480;y++,i++)//设置进度条的Y轴位置
    {
        for(int x=700,j=0;x<800;x++,j++)//设置进度条的长度
        {
            for(int t = 0; t < 4; t++) {
                p[(y*800+x)*4+t]=bmp[(i*100+j)*4+t];
            }   
        }
    }
    close(bmpfd);
    return 0;
}

int fanhui_bmp(int lcdfd, char *bmpname, char* p)
{
    // 2.打开bmp图片文件
    int bmpfd = open(bmpname,O_RDWR);
    if(bmpfd == -1)
    {
        printf("打开图片失败\n");
        return 0;
    }
    // 内存映射   
    p = mmap(NULL,800*480*4,PROT_READ|PROT_WRITE,MAP_SHARED,lcdfd,0);

    //3.读取bmp图片的数据
    char buf[100*100*3]={0};//800*480:图片像素点总数 *3：C的代码单位是字节
    //跳过表示图片信息的54个字节
    read(bmpfd,buf,54);
    read(bmpfd,buf,100*100*3);
    //添加一个字节
    char bmp[100*100*4]={0};//每个像素点加入一个字节所以大小变成*4
    for(int i=0,j=0;i<100*100*3;i+=3,j+=4)//i+=3:表示每隔RGB加入一个字节,j+=4:表示跳过ARGB
    {
        bmp[j]=buf[i];
        bmp[j+1]=buf[i+1];
        bmp[j+2]=buf[i+2];
        bmp[j+3]=0;
    }

    //380~480(高),350~450(宽)
    //4.将读取出来的图片数据写入到液晶屏上
    for(int y=380,i=0;y<480;y++,i++)//设置进度条的Y轴位置
    {
        for(int x=350,j=0;x<450;x++,j++)//设置进度条的长度
        {
            for(int t = 0; t < 4; t++) {
                p[(y*800+x)*4+t]=bmp[(i*100+j)*4+t];
            }   
        }
    }
    close(bmpfd);
    return 0;
}

int main()
{
    int lcdfd = open("/dev/fb0",O_RDWR);
    if(lcdfd == -1)
    {
        printf("打开液晶屏失败\n");
        return 0;
    }

    touch_fd = open("/dev/input/event0",O_RDWR);
    if(touch_fd == -1)
    {
        printf("打开触摸屏失败\n");
        return -1;
    }
    // 内存映射
    p1 = mmap(NULL,800*480*4,PROT_READ|PROT_WRITE,MAP_SHARED,lcdfd,0);
    show_bmp("1.bmp", p1);
    show_bmp0("jindutiao1.bmp", bmp0);
    show_bmp0("1.bmp", bmp1);
    int x,y,x1=200,flag=0;
    while(1)
    {
        event(&x,&y);
        if(x<x1&&150<y && y<430)//x1表示区域：0~200 0~400  0~600  0~800 
        {
            hua(x, bmp0, bmp1);
            flag=1;//记录每次的区域
        }
        if(x>=x1&&150<y && y<430)//当手指到达下一个区域时，更改下一个区域坐标
        {
            if(flag==1)//只有进入到前一个区域才能解锁下一个区域的坐标
                x1+=200;
            flag=0;
        }
        if(x>750&&x1>=800&&150<y && y<430)
        {
            printf("解锁成功\n");
            break;
        }
        
    }
    munmap(p1,800*480*4);
    while (1) {
        show_bmp2(lcdfd, "d1.bmp", dp1);
        for (int i = 0; i < 100000000/2; i++) {
        }
        show_bmp2(lcdfd, "d2.bmp", dp2);
        for (int i = 0; i < 100000000/2; i++) {   
        }
        show_bmp2(lcdfd, "d3.bmp", dp3);
        for (int i = 0; i < 100000000/2; i++) {
        }
        show_bmp2(lcdfd, "d4.bmp", dp4);
        for (int i = 0; i < 100000000/2; i++) {   
        }
        show_bmp2(lcdfd, "d5.bmp", dp5);
        for (int i = 0; i < 100000000/2; i++) {
        }
        show_bmp2(lcdfd, "d6.bmp", dp6);
        for (int i = 0; i < 100000000/2; i++) {   
        }
        show_bmp2(lcdfd, "d7.bmp", dp7);
        for (int i = 0; i < 100000000/2; i++) {
        }
        show_bmp2(lcdfd, "d8.bmp", dp8);
        for (int i = 0; i < 100000000/2; i++) {   
        }
        show_bmp2(lcdfd, "d9.bmp", dp9);
        for (int i = 0; i < 100000000/2; i++) {   
        }
        break;
    }


    while (1) {

        // show_bmp2(lcdfd, "4.bmp", p2);
        show_bmp2(lcdfd, "4.bmp", p2);
        // munmap(p2,800*480*4);

        //60~420(高),30~390(宽)
        // show_bmp2(lcdfd, "4.bmp", xiangce_p);
        xiangce_bmp(lcdfd, "xiangce.bmp", xiangce_p);
        // int x,y,x1=200,flag=0;
        int x2 = -1, y2 = -1;

        // int flag2 = 0;

        int flag_tupian = 0;

        int x3 = -1, y3 = -1;

        // int x4 = -1, y4 = -1;

        int x2_1 = 30, x2_2 = 390, y2_1 = 60, y2_2 = 420;

        //380~480(高),0~100(宽) (左)
        int x3_1 = 0, x3_2 = 100, y3_1 = 380, y3_2 = 480; 
        //380~480(高),700~800(宽) (右)
        int x4_1 = 700, x4_2 = 800, y4_1 = 380, y4_2 = 480;
        //380~480(高),350~450(宽) (返回)
        int x5_1 = 350, x5_2 = 450, y5_1 = 380, y5_2 = 480;

        while(1)
        {
            event2(&x2,&y2);
            // if(x2_1 <= x2 <= x2_2 && y2_1 <= y2 <= y2_2)//x1表示区域：0~200 0~400  0~600  0~800 
            // {
            //     tupian_bmp(lcdfd, "3.bmp", tupian1_p);
            //     break;
            // } 

            // 检查触摸按键事件
            if (ts.type == EV_KEY && ts.code == BTN_TOUCH) {
                if (ts.value == 1 && x2_1 <= x2 && x2 <= x2_2 && y2_1 <= y2 && y2 <= y2_2) {  // 按下事件
                    printf("(%d %d)\n", x2, y2);
                    tupian_bmp(lcdfd, "1.bmp", tupian1_p, &flag_tupian);
                    zuo_bmp(lcdfd, "zuo.bmp", zuo_p);
                    you_bmp(lcdfd, "you.bmp", you_p);
                    fanhui_bmp(lcdfd, "fanhui.bmp", fanhui_p);
                    break;  // 显示一次后退出循环
                }
            }  
        }

        while(1)
        {
            event2(&x3,&y3);

            // 检查触摸按键事件
            if (ts.type == EV_KEY && ts.code == BTN_TOUCH) {
                if (ts.value == 1 && x3_1 <= x3 && x3 <= x3_2 && y3_1 <= y3 && y3 <= y3_2 && flag_tupian == 1) {  // 按下事件
                    ts.value = 0;
                    printf("(%d %d)\n", x3, y3);
                    tupian_bmp(lcdfd, "3.bmp", tupian3_p, &flag_tupian);
                    // flag_tupian = 0;
                    zuo_bmp(lcdfd, "zuo.bmp", zuo_p);
                    you_bmp(lcdfd, "you.bmp", you_p);
                    fanhui_bmp(lcdfd, "fanhui.bmp", fanhui_p);
                    // while (1) {
                    //     printf("%d\n", flag_tupian);
                    //     if (ts.value == 0) {
                            // flag_tupian = 3;
                    //         break;
                    //     }
                    //     printf("%d\n", ts.value);
                    // }
                    // break;  // 显示一次后退出循环
                }
            }  

            if (ts.type == EV_KEY && ts.code == BTN_TOUCH) {
                if (ts.value == 1 && x4_1 <= x3 && x3 <= x4_2 && y4_1 <= y3 && y3 <= y4_2 && flag_tupian == 1) {  // 按下事件
                    ts.value = 0;
                    printf("(%d %d)\n", x3, y3);
                    tupian_bmp(lcdfd, "2.bmp", tupian2_p, &flag_tupian);
                    // flag_tupian = 0;
                    zuo_bmp(lcdfd, "zuo.bmp", zuo_p);
                    you_bmp(lcdfd, "you.bmp", you_p);
                    fanhui_bmp(lcdfd, "fanhui.bmp", fanhui_p);
                    // break;  // 显示一次后退出循环
                    // while (1) {
                    //     if (ts.value == 0) {
                            // flag_tupian = 2;
                    //         break;
                    //     }
                    // }
                }
            } 

            // 检查触摸按键事件
            if (ts.type == EV_KEY && ts.code == BTN_TOUCH) {
                if (ts.value == 1 && x3_1 <= x3 && x3 <= x3_2 && y3_1 <= y3 && y3 <= y3_2 && flag_tupian == 2) {  // 按下事件
                    ts.value = 0;
                    printf("(%d %d)\n", x3, y3);
                    tupian_bmp(lcdfd, "1.bmp", tupian3_p, &flag_tupian);
                    // flag_tupian = 0;
                    zuo_bmp(lcdfd, "zuo.bmp", zuo_p);
                    you_bmp(lcdfd, "you.bmp", you_p);
                    fanhui_bmp(lcdfd, "fanhui.bmp", fanhui_p);
                    // break;  // 显示一次后退出循环
                    // while (1) {
                    //     if (ts.value == 0) {
                            // flag_tupian = 1;
                    //         break;
                    //     }
                    // }
                }
            }  

            if (ts.type == EV_KEY && ts.code == BTN_TOUCH) {
                if (ts.value == 1 && x4_1 <= x3 && x3 <= x4_2 && y4_1 <= y3 && y3 <= y4_2 && flag_tupian == 2) {  // 按下事件
                    ts.value = 0;
                    printf("(%d %d)\n", x3, y3);
                    tupian_bmp(lcdfd, "3.bmp", tupian2_p, &flag_tupian);
                    // flag_tupian = 0;
                    zuo_bmp(lcdfd, "zuo.bmp", zuo_p);
                    you_bmp(lcdfd, "you.bmp", you_p);
                    fanhui_bmp(lcdfd, "fanhui.bmp", fanhui_p);
                    // break;  // 显示一次后退出循环
                    // while (1) {
                    //     if (ts.value == 0) {
                            // flag_tupian = 3;
                    //         break;
                    //     }
                    // }
                }
            } 

            // 检查触摸按键事件
            if (ts.type == EV_KEY && ts.code == BTN_TOUCH) {
                if (ts.value == 1 && x3_1 <= x3 && x3 <= x3_2 && y3_1 <= y3 && y3 <= y3_2 && flag_tupian == 3) {  // 按下事件
                    ts.value = 0;
                    printf("(%d %d)\n", x3, y3);
                    tupian_bmp(lcdfd, "2.bmp", tupian3_p, &flag_tupian);
                    // flag_tupian = 0;
                    zuo_bmp(lcdfd, "zuo.bmp", zuo_p);
                    you_bmp(lcdfd, "you.bmp", you_p);
                    fanhui_bmp(lcdfd, "fanhui.bmp", fanhui_p);
                    // break;  // 显示一次后退出循环
                    // while (1) {
                    //     if (ts.value == 0) {
                            // flag_tupian = 2;
                    //         break;
                    //     }
                    // }
                }
            }  

            if (ts.type == EV_KEY && ts.code == BTN_TOUCH) {
                if (ts.value == 1 && x4_1 <= x3 && x3 <= x4_2 && y4_1 <= y3 && y3 <= y4_2 && flag_tupian == 3) {  // 按下事件
                    ts.value = 0;
                    printf("(%d %d)\n", x3, y3);
                    tupian_bmp(lcdfd, "1.bmp", tupian2_p, &flag_tupian);
                    // flag_tupian = 0;
                    zuo_bmp(lcdfd, "zuo.bmp", zuo_p);
                    you_bmp(lcdfd, "you.bmp", you_p);
                    fanhui_bmp(lcdfd, "fanhui.bmp", fanhui_p);
                    // break;  // 显示一次后退出循环
                    // while (1) {
                    //     if (ts.value == 0) {
                            // flag_tupian = 1;
                    //         break;
                    //     }
                    // }
                }
            } 

            if (ts.type == EV_KEY && ts.code == BTN_TOUCH) {
                if (ts.value == 1 && x5_1 <= x3 && x3 <= x5_2 && y5_1 <= y3 && y3 <= y5_2) {  // 按下事件
                    // ts.value = 0;
                    printf("(%d %d)\n", x3, y3);
                    // tupian_bmp(lcdfd, "1.bmp", tupian2_p, &flag_tupian);
                    // flag_tupian = 0;
                    // fanhui_bmp(lcdfd, "fanhui.bmp", zuo_p);
                    printf("break之前！\n");
                    break;  // 显示一次后退出循环
                    // while (1) {
                    //     if (ts.value == 0) {
                            // flag_tupian = 1;
                    //         break;
                    //     }
                    // }
                }
            }
            printf("break之后！\n");
        }

        // while(1)
        // {
        //     event2(&x4,&y4);

        //     // 检查触摸按键事件
        //     if (ts.type == EV_KEY && ts.code == BTN_TOUCH) {
        //         if (ts.value == 1 && x3_1 <= x4 <= x3_2 && y3_1 <= y4 <= y3_2 && flag2 == 3) {  // 按下事件
        //             printf("(%d %d)\n", x4, y4);
        //             tupian_bmp(lcdfd, "3.bmp", tupian3_p);
        //             flag2 = 2;
        //             zuo_bmp(lcdfd, "zuo.bmp", zuo_p);
        //             you_bmp(lcdfd, "you.bmp", you_p);
        //             break;  // 显示一次后退出循环
        //         }
        //     }  

        //     if (ts.type == EV_KEY && ts.code == BTN_TOUCH) {
        //         if (ts.value == 1 && x3_1 <= x4 <= x3_2 && y3_1 <= y4 <= y3_2 && flag2 == 2) {  // 按下事件
        //             printf("(%d %d)\n", x4, y4);
        //             tupian_bmp(lcdfd, "2.bmp", tupian2_p);
        //             flag2 = 1;
        //             zuo_bmp(lcdfd, "zuo.bmp", zuo_p);
        //             you_bmp(lcdfd, "you.bmp", you_p);
        //             break;  // 显示一次后退出循环
        //         }
        //     }

        //     if (ts.type == EV_KEY && ts.code == BTN_TOUCH) {
        //         if (ts.value == 1 && x4_1 <= x4 <= x4_2 && y4_1 <= y4 <= y4_2 && flag2 == 3) {  // 按下事件
        //             printf("(%d %d)\n", x4, y4);
        //             tupian_bmp(lcdfd, "3.bmp", tupian3_p);
        //             flag2 = 1;
        //             zuo_bmp(lcdfd, "zuo.bmp", zuo_p);
        //             you_bmp(lcdfd, "you.bmp", you_p);
        //             break;  // 显示一次后退出循环
        //         }
        //     } 

        //     if (ts.type == EV_KEY && ts.code == BTN_TOUCH) {
        //         if (ts.value == 1 && x4_1 <= x4 <= x4_2 && y4_1 <= y4 <= y4_2 && flag2 == 2) {  // 按下事件
        //             printf("(%d %d)\n", x4, y4);
        //             tupian_bmp(lcdfd, "2.bmp", tupian2_p);
        //             flag2 = 3;
        //             zuo_bmp(lcdfd, "zuo.bmp", zuo_p);
        //             you_bmp(lcdfd, "you.bmp", you_p);
        //             break;  // 显示一次后退出循环
        //         }
        //     } 
        // }

    }
    



    close(lcdfd);
    close(touch_fd);
    return 0;
}
